Sound Classification using temporal augmentation and Mel frequency cepstral coefficients
Looking at the data¶
Loading Libraries¶
In [30]:
# System and os level library imports
import time
import sys
import os
# array handling library imports
import pandas as pd
import numpy as np
# Sound processing library imports
import librosa
import librosa.display as display
# plotting library imports
import matplotlib.pyplot as plt
%matplotlib inline
# play sound in jupyter notebook
import IPython.display as ipd
# save the entities for futur use
import pickle
# Model building related libraries
import sklearn
from sklearn import metrics
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import LabelEncoder
# Deep learning library import
import keras.backend as K
from keras.utils import np_utils
from keras.models import model_from_json
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten,BatchNormalization,Convolution2D, MaxPooling2D,Bidirectional, LSTM,SimpleRNN
from keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard
from keras.optimizers import Adam
Defining some useful functions¶
In [31]:
def saveModel(model_obj,model_file_name, weights_file_name = None):
"""Save keras model to disk."""
if weights_file_name is None:
weights_file_name = model_file_name
model_json = model_obj.to_json()
with open("new_models/{}.json".format(model_file_name), "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model_obj.save_weights("new_models/{}.h5".format(weights_file_name))
print("Saved model {} to disk".format(model_file_name))
In [32]:
def loadModel(model_file_name, weights_file_name = None):
"""Load keras model from disk."""
if weights_file_name is None:
weights_file_name = model_file_name
# load json and create model
json_file = open('./new_models/{}.json'.format(model_file_name), 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("./new_models/{}.h5".format(weights_file_name))
print("Loaded model {} from disk".format(model_file_name))
return loaded_model
In [33]:
def get_predicted_classes(model_obj, val_data, test_data= None):
"""Function to return predicted classes."""
val_preds = model_obj.predict_classes(val_data)
if test_data is not None:
test_preds = model_obj.predict_classes(test_data)
return (val_preds, test_preds)
return val_preds
In [34]:
def get_predicted_class_prob(model_obj, val_data, test_data= None):
"""Function to return predicted class probabilities."""
val_preds = pd.DataFrame(model_obj.predict_proba(val_data))
if test_data is not None:
test_preds = pd.DataFrame(model_obj.predict_proba(test_data))
return (val_preds, test_preds)
return val_preds
In [35]:
def print_metrics(model_obj, train_x, train_y, test_x, test_y):
"""Function to print the model metrics."""
print(model_obj.metrics_names)
print(model_obj.evaluate(train_x, train_y))
print(model_obj.evaluate(test_x, test_y))
train_preds = model_obj.predict_classes(train_x)
test_preds = model_obj.predict_classes(test_x)
target_names = lb.classes_
return (pd.DataFrame(classification_report(y_pred=test_preds,
y_true=test_y.argmax(axis=1),
target_names = target_names,
output_dict = True
)))
In [36]:
os.getcwd()
Out[36]:
In [37]:
path = "/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/"
In [38]:
data_info = {}
for genre in os.listdir(path):
f = os.listdir(path+'/'+str(genre))
data_info[genre]=len(f)
In [39]:
data_info
Out[39]:
In [40]:
ipd.Audio('/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/blues/blues.00000.au_original.wav') # load a local WAV file
Out[40]:
In [41]:
d,sr = librosa.load('/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/blues/blues.00000.au_original.wav') # load a local WAV file
Visualizing Audio¶
In [42]:
plt.axis('off')
plt.style.use('ggplot')
plt.style.use(['dark_background'])
plt.figure(figsize=(14, 5),)
librosa.display.waveplot(d, sr=sr,color='r',)
Out[42]:
X - time y - amplitude
Spectogram¶
In [43]:
X = librosa.stft(d)
Xdb = librosa.amplitude_to_db(abs(X))
plt.figure(figsize=(14, 5))
librosa.display.specshow(Xdb, sr=sr, x_axis='time', y_axis='hz')
plt.title(" of the sample song")
plt.colorbar()
plt.show()
In [44]:
librosa.display.specshow(Xdb, sr=sr, x_axis='time', y_axis='log')
plt.title("Log transormed frequency")
plt.colorbar()
plt.show()
Feature extraction¶
Zero Crossing Rate¶
The zero crossing rate is the rate of sign-changes along a signal, i.e., the rate at which the signal changes from positive to negative or back.
In [45]:
np.sum(librosa.feature.zero_crossing_rate(d))
Out[45]:
Spectral Centroid¶
It indicates where the centre of mass for a sound is located and is calculated as the weighted mean of the frequencies present in the sound.
Consider two songs, one from a blues genre and the other belonging to metal. Now as compared to the blues genre song which is the same throughout its length, the metal song has more frequencies towards the end. So spectral centroid for blues song will lie somewhere near the middle of its spectrum while that for a metal song would be towards its end.
In [46]:
# Normalising the spectral centroid for visualisation
def normalize(d, axis=0):
"""This function will scale the features along the time axis by default."""
return sklearn.preprocessing.minmax_scale(d, axis=axis)
In [47]:
def plot_spectral_centroid(d,genre):
"""Function to plot the spectral centroid."""
spectral_centroids = librosa.feature.spectral_centroid(d, sr=sr)[0]
# Computing the time variable for visualization
frames = range(len(spectral_centroids))
t = librosa.frames_to_time(frames)
#Plotting the Spectral Centroid along the waveform
fig, ax = plt.subplots( nrows=1, ncols=1 )
librosa.display.waveplot(d, sr=sr, alpha=0.4)
plt.plot(t, normalize(spectral_centroids), color='r')
plt.title("Spectral Centroid of a {} song".format(genre))
plt.axhline(y=0.5, color='black', linestyle='--')
fig.set_size_inches(9.25, 4.5)
fig.savefig('img/{}_spectral_centroid.png'.format(genre))
plt.show()
In [48]:
for k in data_info.keys():
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.00000.au_original.wav'.format(k,k)
d,sr = librosa.load(data_path)
plot_spectral_centroid(d,k)
Spectral Rolloff¶
It is a measure of the shape of the signal. It represents the frequency below which a specified percentage of the total spectral energy, e.g. 85%, lies.
In [49]:
def plot_spectral_rolloff(d,genre):
"""Function to plot the spectral roll off."""
#Plotting the Spectral Rolloff along the waveform
fig, ax = plt.subplots( nrows=1, ncols=1 )
spectral_rolloff = librosa.feature.spectral_rolloff(d+0.01, sr=sr)[0]
librosa.display.waveplot(d, sr=sr, alpha=0.4)
frames = range(len(spectral_rolloff))
t = librosa.frames_to_time(frames)
plt.plot(t, normalize(spectral_rolloff), color='r')
plt.title("Spectral Rolloff of a {} song".format(genre))
plt.axhline(y=0.5, color='black', linestyle='--')
fig.set_size_inches(9.25, 4.5)
fig.savefig('img/{}_spectral_rolloff.png'.format(genre))
plt.show()
In [50]:
for k in data_info.keys():
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.00000.au_original.wav'.format(k,k)
d,sr = librosa.load(data_path)
plot_spectral_rolloff(d,k)
Mel-Frequency Cepstral Coefficients¶
The Mel frequency cepstral coefficients (MFCCs) of a signal are a small set of features (usually about 10–20) which concisely describe the overall shape of a spectral envelope. It models the characteristics of the human voice.
In [51]:
def plot_mfcc(d,genre):
"""Function to plot the mfcc."""
fig, ax = plt.subplots( nrows=1, ncols=1 )
mfccs = librosa.feature.mfcc(d)
librosa.display.specshow(mfccs, sr=sr, x_axis='time')
fig.savefig('img/{}_mfcc.png'.format(genre))
plt.show()
return mfccs
In [52]:
for k in data_info.keys():
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.00000.au_original.wav'.format(k,k)
d,sr = librosa.load(data_path)
mfccs = plot_mfcc(d,k)
In [53]:
mfccs = sklearn.preprocessing.scale(mfccs, axis=1)
plt.figure(figsize=(15, 5))
librosa.display.specshow(mfccs, sr=sr, x_axis='time')
Out[53]:
Chroma Frequencies¶
Chroma features are an interesting and powerful representation for music audio in which the entire spectrum is projected onto 12 bins representing the 12 distinct semitones (or chroma) of the musical octave.
In [54]:
hop_length = 512
chromagram = librosa.feature.chroma_stft(d, sr=sr, hop_length=hop_length)
plt.figure(figsize=(15, 5))
librosa.display.specshow(chromagram, x_axis='time', y_axis='chroma', hop_length=hop_length, cmap='coolwarm')
Out[54]:
In [55]:
def extract_features(y,sr):
"""This function extracts the features from songs,
We are extracting the Chroma features, spectral centroid, spectral bandwidth, spectral roll off, zero crossing rate and the mfccc's"""
chroma_freq = librosa.feature.chroma_stft(y=y, sr=sr)
specral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
spectral_bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)
spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)
zero_crossing_rate = librosa.feature.zero_crossing_rate(y)
mfcc = np.mean(librosa.feature.mfcc(y=y, sr=sr,n_mfcc=39).T,axis = 0)
chroma_freq_arr = np.mean(np.ndarray.flatten(chroma_freq))
spectral_centroid_arr = np.mean(np.ndarray.flatten(specral_centroid))
spectral_bandwidth_arr = np.mean(np.ndarray.flatten(spectral_bandwidth))
spectral_rolloff_arr = np.mean(np.ndarray.flatten(spectral_rolloff))
zero_crossing_rate_arr = np.mean(np.ndarray.flatten(zero_crossing_rate))
mfcc_arr = np.ndarray.flatten(mfcc)
temp = np.array([chroma_freq_arr,spectral_centroid_arr,spectral_bandwidth_arr,spectral_rolloff_arr,zero_crossing_rate_arr])
all_features = np.concatenate([temp,mfcc_arr])
return all_features
In [56]:
def loadAudioDataExtractFeatures(file_ID,genre, file_format = 'wav'):
"""Load song and extract the features using the extract_features function"""
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.wav'.format(genre,file_ID)
y,sr = librosa.load(data_path)
features = extract_features(y,sr)
return features
Extracting the features from the songs¶
In [57]:
# X = []
# y= []
# for genre in os.listdir(path):
# print("genre",genre)
# path_genre = path+'/'+str(genre)
# for i in os.listdir(path_genre):
# if i.endswith('wav'):
# file_ID = i.strip('.wav') #file format already provided
# X.append(loadAudioDataExtractFeatures(genre= genre,file_ID=file_ID))
# y.append(genre)
# print("genre ended",genre)
Saving the numpy arrays extracted¶
In [58]:
# np.save('X_train_many_features.npy', np.array(X))
X = np.load('X_train_many_features.npy')
In [59]:
# np.save('y_train_many_features.npy', np.array(y))
In [60]:
y = np.load('y_train_many_features.npy')
label encoder¶
In [61]:
X = np.array(X)
y = np.array(y)
lb = LabelEncoder()
y = to_categorical(lb.fit_transform(y))
In [62]:
pickle.dump(lb, open("label_encoder.pkl","wb"), protocol=pickle.HIGHEST_PROTOCOL)
In [63]:
num_labels = y.shape[1]
In [65]:
def recall(y_true, y_pred):
"""Recall metric.
Only computes a batch-wise average of recall.
Computes the recall, a metric for multi-label classification of
how many relevant items are selected.
"""
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = true_positives / (possible_positives + K.epsilon())
return recall
In [66]:
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 124)
scaling¶
In [67]:
scaler = StandardScaler()
scaler.fit(np.array(x_train[:, :-1], dtype = float))
x_train= scaler.transform(np.array(x_train[:, :-1], dtype = float))
x_test = scaler.transform(np.array(x_test[:, :-1], dtype = float))
In [68]:
pickle.dump(scaler, open("scaler.pkl","wb"), protocol=pickle.HIGHEST_PROTOCOL)
In [69]:
# with open('scaler.pkl', 'rb') as pickle_file:
# tep = pickle.load(pickle_file)
In [70]:
scaler.mean_
Out[70]:
Model Building¶
Basic Neural Network¶
In [71]:
model_name = 'Basic_NN'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=50),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=50),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=50),tb]
model_basic_nn = Sequential()
input_shape = x_train.shape[1]
num_labels = 10
model_basic_nn.add(Dense(256, input_shape=(input_shape,)))
model_basic_nn.add(Activation('relu'))
model_basic_nn.add(Dense(128))
model_basic_nn.add(Activation('relu'))
model_basic_nn.add(Dense(num_labels))
model_basic_nn.add(Activation('softmax'))
model_basic_nn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [72]:
model_basic_nn.summary()
In [76]:
%time model_basic_nn.fit(x_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25)
Out[76]:
In [77]:
model_basic_nn.metrics_names
Out[77]:
In [78]:
model_basic_nn.evaluate(x_train, y_train)
Out[78]:
In [79]:
train_preds_basic_nn = model_basic_nn.predict_classes(x_train)
test_preds_basic_nn = model_basic_nn.predict_classes(x_test)
In [80]:
train_preds_basic_nn_proba,test_preds_basic_nn_proba = get_predicted_class_prob(model_basic_nn,x_train, x_test)
train_preds_basic_nn,test_preds_basic_nn = get_predicted_classes(model_basic_nn,x_train, x_test)
In [81]:
saveModel(model_basic_nn,"model_basic_nn")
In [82]:
model_basic_nn = loadModel('model_basic_nn')
In [83]:
model_basic_nn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [84]:
x_train[0]
Out[84]:
In [87]:
model_basic_nn_df = print_metrics(model_basic_nn,x_train,y_train, x_test, y_test)
In [88]:
model_basic_nn_df
Out[88]:
In [92]:
model_basic_nn_df.to_csv("model_basic_nn_df.csv",index=True)
RNN¶
In [93]:
x_rnn_train = x_train.reshape(x_train.shape[0], 1, x_train.shape[1])
x_rnn_test = x_test.reshape(x_test.shape[0], 1, x_test.shape[1])
In [94]:
x_rnn_train.shape
Out[94]:
In [95]:
model_name = 'Basic_RNN'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_basic_rnn = Sequential()
model_basic_rnn.add(SimpleRNN(256 , input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_basic_rnn.add(Dense(256))
model_basic_rnn.add(Activation('relu'))
model_basic_rnn.add(Dropout(0.5))
model_basic_rnn.add(Dense(256))
model_basic_rnn.add(Activation('relu'))
model_basic_rnn.add(Dropout(0.5))
model_basic_rnn.add(Dense(num_labels))
model_basic_rnn.add(Activation('softmax'))
model_basic_rnn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [96]:
model_basic_rnn.summary()
In [104]:
%time model_basic_rnn.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25)
Out[104]:
In [98]:
train_preds_basic_rnn_proba,test_preds_basic_rnn_proba = get_predicted_class_prob(model_basic_rnn,x_rnn_train, x_rnn_test)
train_preds_basic_rnn,test_preds_basic_rnn = get_predicted_classes(model_basic_rnn,x_rnn_train, x_rnn_test)
In [99]:
model_basic_rnn_df = print_metrics(model_basic_rnn,x_rnn_train,y_train,x_rnn_test,y_test )
In [100]:
model_basic_rnn_df
Out[100]:
In [101]:
saveModel(model_basic_rnn,"model_basic_RNN")
In [105]:
model_basic_rnn_df.to_csv("model_basic_rnn_df.csv")
LSTM¶
In [106]:
model_name = 'Basic_LSTM'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_lstm = Sequential()
model_lstm.add(LSTM(256 , input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_lstm.add(BatchNormalization())
model_lstm.add(Dense(256))
model_lstm.add(Activation('relu'))
model_lstm.add(Dropout(0.5))
model_lstm.add(Dense(256))
model_lstm.add(Activation('relu'))
model_lstm.add(Dropout(0.5))
model_lstm.add(Dense(256))
model_lstm.add(Activation('relu'))
model_lstm.add(Dropout(0.5))
model_lstm.add(Dense(num_labels))
model_lstm.add(Activation('softmax'))
model_lstm.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [107]:
model_lstm.summary()
In [109]:
%time model_lstm.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25)
Out[109]:
In [110]:
train_preds_basic_lstm_proba,test_preds_basic_lstm_proba = get_predicted_class_prob(model_lstm,x_rnn_train, x_rnn_test)
train_preds_basic_lstm,test_preds_basic_lstm = get_predicted_classes(model_lstm,x_rnn_train, x_rnn_test)
In [111]:
model_lstm_df = print_metrics(model_lstm,x_rnn_train,y_train, x_rnn_test, y_test)
In [112]:
model_lstm_df
Out[112]:
In [113]:
saveModel(model_lstm, 'Basic_LSTM')
In [114]:
model_lstm_df.to_csv("model_lstm_df.csv")
Bidirectional_LSTM¶
In [115]:
model_name = 'Bidirectional_LSTM'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_bidi_lstm = Sequential()
model_bidi_lstm.add(Bidirectional(LSTM(256 ,return_sequences=True),
input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_bidi_lstm.add(Bidirectional(LSTM(100)))
model_bidi_lstm.add(Dense(256))
model_bidi_lstm.add(Activation('relu'))
model_bidi_lstm.add(Dropout(0.5))
model_bidi_lstm.add(Dense(256))
model_bidi_lstm.add(Activation('relu'))
model_bidi_lstm.add(Dropout(0.5))
model_bidi_lstm.add(Dense(num_labels))
model_bidi_lstm.add(Activation('softmax'))
model_bidi_lstm.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [116]:
model_bidi_lstm.summary()
In [117]:
%time model_bidi_lstm.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25,batch_size=30)
Out[117]:
In [118]:
model_bidi_lstm.summary()
In [119]:
train_preds_basic_bidi_lstm_proba,test_preds_basic_bidi_lstm_proba = get_predicted_class_prob(model_bidi_lstm,x_rnn_train, x_rnn_test)
train_preds_basic_bidi_lstm,test_preds_basic_bidi_lstm = get_predicted_classes(model_bidi_lstm,x_rnn_train, x_rnn_test)
In [120]:
model_bidi_lstm_df = print_metrics(model_bidi_lstm,x_rnn_train,y_train,x_rnn_test,y_test )
In [121]:
model_bidi_lstm_df
Out[121]:
In [122]:
saveModel(model_bidi_lstm,'Bidirectional_LSTM_basic')
In [123]:
model_bidi_lstm_df.to_csv("model_bidi_lstm_df.csv")
New LSTM¶
In [ ]:
model_name = 'New_LSTM'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_lstm2 = Sequential()
model_lstm2.add(LSTM(units=128, dropout=0.05, recurrent_dropout=0.35, return_sequences=True, input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_lstm2.add(LSTM(units=32, dropout=0.05, recurrent_dropout=0.35, return_sequences=False))
model_lstm2.add(Dense(units=num_labels, activation='softmax'))
model_lstm2.add(Dropout(0.5))
model_lstm2.compile(loss='categorical_crossentropy', optimizer=Adam(), metrics=['accuracy',recall])
In [161]:
model_bidi_lstm2.summary()
In [126]:
%time model_lstm2.fit(x_rnn_train, y_train, callbacks = callbacks, batch_size=50, epochs=400, validation_split=0.25)
Out[126]:
In [127]:
train_preds_basic_lstm2_proba,test_preds_basic_lstm2_proba = get_predicted_class_prob(model_lstm2,x_rnn_train, x_rnn_test)
train_preds_basic_lstm2,test_preds_basic_lstm2 = get_predicted_classes(model_lstm2,x_rnn_train, x_rnn_test)
In [128]:
model_lstm2_df = print_metrics(model_lstm2,x_rnn_train,y_train,x_rnn_test,y_test )
In [129]:
model_lstm2_df
Out[129]:
In [130]:
saveModel(model_lstm2,"model_lstm2")
In [131]:
model_lstm2_df.to_csv("model_lstm2_df.csv")
Bi Di LSTM - NEW¶
In [132]:
model_name = 'New_Bidirectional_LSTM-1'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_bidi_lstm2 = Sequential()
model_bidi_lstm2.add(Bidirectional(LSTM(128 ,return_sequences=True),
input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_bidi_lstm2.add(Bidirectional(LSTM(100)))
model_bidi_lstm2.add(Dense(14))
model_bidi_lstm2.add(Activation('relu'))
model_bidi_lstm2.add(Dropout(0.5))
model_bidi_lstm2.add(Dense(num_labels))
model_bidi_lstm2.add(Activation('softmax'))
model_bidi_lstm2.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [162]:
model_bidi_lstm2.summary()
In [133]:
%time model_bidi_lstm2.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25,batch_size=30)
Out[133]:
In [134]:
model_bidi_lstm2.summary()
In [135]:
train_preds_bidi_lstm2_proba,test_preds_bidi_lstm2_proba = get_predicted_class_prob(model_bidi_lstm2,x_rnn_train, x_rnn_test)
train_preds_bidi_lstm2,test_preds_bidi_lstm2 = get_predicted_classes(model_bidi_lstm2,x_rnn_train, x_rnn_test)
In [136]:
model_bidi_lstm2_df = print_metrics(model_bidi_lstm2,x_rnn_train,y_train,x_rnn_test,y_test )
In [137]:
model_bidi_lstm2_df
Out[137]:
In [138]:
saveModel(model_bidi_lstm2,"model_bidi_lstm2")
In [139]:
model_bidi_lstm2_df.to_csv("model_bidi_lstm2_df.csv")
Ensemble of Deep Learning models¶
In [140]:
(train_preds_basic_nn_proba.shape) == (train_preds_basic_rnn_proba.shape) == (train_preds_basic_lstm_proba.shape) == (train_preds_basic_bidi_lstm_proba.shape) == (train_preds_basic_lstm2_proba.shape) == (train_preds_bidi_lstm2_proba.shape)
Out[140]:
In [141]:
(test_preds_basic_nn_proba.shape) == (test_preds_basic_rnn_proba.shape) == (test_preds_basic_lstm_proba.shape) == (test_preds_basic_bidi_lstm_proba.shape) == (test_preds_basic_lstm2_proba.shape) == (test_preds_bidi_lstm2_proba.shape)
Out[141]:
In [142]:
train_proba_lists =[train_preds_basic_nn_proba, train_preds_basic_rnn_proba,train_preds_basic_lstm_proba,train_preds_basic_bidi_lstm_proba,train_preds_basic_lstm2_proba,train_preds_bidi_lstm2_proba]
In [143]:
test_proba_lists =[test_preds_basic_nn_proba, test_preds_basic_rnn_proba,test_preds_basic_lstm_proba,test_preds_basic_bidi_lstm_proba,test_preds_basic_lstm2_proba,test_preds_bidi_lstm2_proba]
In [144]:
train_ensem_proba = pd.concat([i for i in train_proba_lists],axis = 1)
In [145]:
test_ensem_proba = pd.concat([i for i in test_proba_lists],axis = 1)
In [147]:
model_name = 'Ensemble_NN'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_ensemble_nn = Sequential()
model_ensemble_nn.add(Dense(128, input_shape=(train_ensem_proba.shape[1],)))
model_ensemble_nn.add(Activation('relu'))
model_ensemble_nn.add(Dropout(0.5))
model_ensemble_nn.add(Dense(65))
model_ensemble_nn.add(Activation('relu'))
model_ensemble_nn.add(Dropout(0.5))
model_ensemble_nn.add(Dense(num_labels))
model_ensemble_nn.add(Activation('softmax'))
model_ensemble_nn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
In [148]:
model_ensemble_nn.summary()
In [152]:
%time model_ensemble_nn.fit(train_ensem_proba,y_train,callbacks = callbacks,epochs=15000, validation_split=0.25)
Out[152]:
In [150]:
model_ensemble_nn_df = print_metrics(model_ensemble_nn,train_ensem_proba,y_train,test_ensem_proba,y_test )
In [151]:
model_ensemble_nn_df
Out[151]:
In [153]:
saveModel(model_ensemble_nn,'model_ensemble_nn')
In [154]:
model_ensemble_nn_df.to_csv("model_ensemble_nn_df.csv")
create a df for plotting¶
In [155]:
model_perf_train_df_names = ['model_basic_nn_df','model_basic_rnn_df','model_lstm_df',
'model_bidi_lstm_df', 'model_lstm2_df', 'model_bidi_lstm2_df']
In [156]:
model_perf_train_df = [model_basic_nn_df,model_basic_rnn_df,model_lstm_df,
model_bidi_lstm_df, model_lstm2_df, model_bidi_lstm2_df]
In [157]:
model_basic_nn_df
Out[157]:
In [158]:
all_model_stats = pd.DataFrame([],columns=lb.classes_)
all_model_stats['model'] = ''
In [159]:
for i in zip(model_perf_train_df_names,model_perf_train_df):
i[1]['model'] = i[0]
all_model_stats = pd.concat([all_model_stats,i[1]], axis = 0)
In [160]:
all_model_stats
Out[160]:
In [187]:
all_models_recall = pd.read_csv("all_models_recall.csv")
In [188]:
all_models_recall
Out[188]:
In [195]:
fig, ax = plt.subplots( nrows=1, ncols=1 )
plt.bar(all_models_recall['Model Name'], all_models_recall['Number of parameters'])
plt.xticks(rotation=70)
plt.title("Number of parameters")
plt.show()
